#pragma once

#include "utils/optimized_price_history.h"
#include "utils/memory_pool.h"
#include <string>
#include <unordered_map>
#include <memory>
#include <mutex>
#include <vector>

namespace hft {

/**
 * @brief 优化的多价格历史管理器
 * 
 * 这个类管理多个交易品种的价格历史，使用内存池和SIMD优化来提高性能。
 */
class OptimizedMultiPriceHistory {
public:
    /**
     * @brief 构造函数
     * @param default_capacity 默认容量
     */
    explicit OptimizedMultiPriceHistory(size_t default_capacity = 1000)
        : default_capacity_(default_capacity) {
    }

    /**
     * @brief 添加价格
     * @param symbol 交易品种
     * @param price 价格
     */
    void addPrice(const std::string& symbol, double price) {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = price_histories_.find(symbol);
        if (it == price_histories_.end()) {
            // 创建新的价格历史
            auto history = std::make_shared<OptimizedPriceHistory>(default_capacity_);
            price_histories_[symbol] = history;
            it = price_histories_.find(symbol);
        }
        
        it->second->addPrice(price);
    }

    /**
     * @brief 获取特定品种的价格历史
     * @param symbol 交易品种
     * @return 价格历史指针
     */
    std::shared_ptr<OptimizedPriceHistory> getPriceHistory(const std::string& symbol) const {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = price_histories_.find(symbol);
        if (it != price_histories_.end()) {
            return it->second;
        }
        
        return nullptr;
    }

    /**
     * @brief 获取所有交易品种
     * @return 交易品种列表
     */
    std::vector<std::string> getSymbols() const {
        std::lock_guard<std::mutex> lock(mutex_);
        
        std::vector<std::string> symbols;
        symbols.reserve(price_histories_.size());
        
        for (const auto& pair : price_histories_) {
            symbols.push_back(pair.first);
        }
        
        return symbols;
    }

    /**
     * @brief 获取特定品种的价格数量
     * @param symbol 交易品种
     * @return 价格数量
     */
    size_t getCount(const std::string& symbol) const {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = price_histories_.find(symbol);
        if (it != price_histories_.end()) {
            return it->second->getCount();
        }
        
        return 0;
    }

    /**
     * @brief 获取特定品种的最新价格
     * @param symbol 交易品种
     * @return 最新价格
     */
    double getLatestPrice(const std::string& symbol) const {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = price_histories_.find(symbol);
        if (it != price_histories_.end()) {
            return it->second->getLatestPrice();
        }
        
        return 0.0;
    }

    /**
     * @brief 计算特定品种的移动平均
     * @param symbol 交易品种
     * @param window_size 窗口大小
     * @return 移动平均值
     */
    double calculateSMA(const std::string& symbol, size_t window_size) const {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = price_histories_.find(symbol);
        if (it != price_histories_.end()) {
            return it->second->calculateSMA(window_size);
        }
        
        return 0.0;
    }

    /**
     * @brief 计算特定品种的指数移动平均
     * @param symbol 交易品种
     * @param window_size 窗口大小
     * @return 指数移动平均值
     */
    double calculateEMA(const std::string& symbol, size_t window_size) const {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = price_histories_.find(symbol);
        if (it != price_histories_.end()) {
            return it->second->calculateEMA(window_size);
        }
        
        return 0.0;
    }

    /**
     * @brief 计算特定品种的标准差
     * @param symbol 交易品种
     * @param window_size 窗口大小
     * @return 标准差
     */
    double calculateStdDev(const std::string& symbol, size_t window_size) const {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = price_histories_.find(symbol);
        if (it != price_histories_.end()) {
            return it->second->calculateStdDev(window_size);
        }
        
        return 0.0;
    }

    /**
     * @brief 计算两个品种的相关系数
     * @param symbol1 第一个交易品种
     * @param symbol2 第二个交易品种
     * @param window_size 窗口大小
     * @return 相关系数
     */
    double calculateCorrelation(const std::string& symbol1, const std::string& symbol2, size_t window_size) const {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it1 = price_histories_.find(symbol1);
        auto it2 = price_histories_.find(symbol2);
        
        if (it1 != price_histories_.end() && it2 != price_histories_.end()) {
            auto prices1 = it1->second->getPrices();
            auto prices2 = it2->second->getPrices();
            
            // 确保有足够的数据
            if (prices1.size() < window_size || prices2.size() < window_size) {
                return 0.0;
            }
            
            // 使用SIMD优化的相关系数计算
            return utils::simd::correlation(
                prices1.data() + (prices1.size() - window_size),
                prices2.data() + (prices2.size() - window_size),
                window_size
            );
        }
        
        return 0.0;
    }

    /**
     * @brief 清除特定品种的价格历史
     * @param symbol 交易品种
     */
    void clear(const std::string& symbol) {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = price_histories_.find(symbol);
        if (it != price_histories_.end()) {
            it->second->clear();
        }
    }

    /**
     * @brief 清除所有价格历史
     */
    void clearAll() {
        std::lock_guard<std::mutex> lock(mutex_);
        
        for (auto& pair : price_histories_) {
            pair.second->clear();
        }
    }

private:
    size_t default_capacity_;  // 默认容量
    std::unordered_map<std::string, std::shared_ptr<OptimizedPriceHistory>> price_histories_;  // 价格历史映射表
    mutable std::mutex mutex_;  // 互斥锁
};

} // namespace hft